home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’94 / [√] Distribution Restricted! / Brian Hamlin / Boom! / Boom.c < prev    next >
C/C++ Source or Header  |  1994-07-04  |  13KB  |  539 lines
  1. /*
  2.     Boom!  A quick Hack to Show off PPC graphics (68k version)
  3.  
  4.     @MacHack94     bh      noEsis Software Construction 
  5. */
  6.  
  7. //****************************************************************
  8. //                                                I N C L U D E S
  9.  
  10. #include <Types.h>
  11. #include <Memory.h>
  12. #include <A4Stuff.h>
  13. #include <SetUpA4.h>
  14. #include <Quickdraw.h>
  15. #include <QDOffscreen.h>
  16. #include <LowMem.h>
  17. #include <Errors.h>
  18. #include <GestaltEqu.h>
  19. #include <Resources.h>
  20. #include <Events.h>
  21. #include <Windows.h>
  22. #include <Sound.h>
  23.  
  24. #include <MixedMode.h>
  25.  
  26. #include <fp.h>
  27. #undef NAN
  28. #include <SANE.h>
  29.  
  30.  
  31. //****************************************************************
  32. //                                                C O N S T A N T S
  33. #define FALSE                false
  34. #define TRUE                true
  35. #define NIL                    0L
  36.  
  37.  
  38. //******************************
  39. //    The 68k code goes in a normal INIT resource.
  40. //    Be sure this is set to "system heap/locked".
  41.  
  42. #define kInitRezType        'INIT'
  43. #define kInitRezID            300
  44.  
  45. #define kMinSystemVersion    (0x0603)
  46.  
  47.  
  48.  
  49. //******************************
  50. // from Windows.h:
  51. // pascal Boolean TrackGoAway( WindowPtr theWindow, Point thePt)
  52. //   ONEWORDINLINE(0xA91E);
  53.  
  54. enum {
  55.  
  56.     kTrackGoAwayInfo = kCStackBased 
  57.                             | RESULT_SIZE(SIZE_CODE(sizeof(Boolean))) 
  58.                             | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr)))
  59.                             | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Point)))
  60. };
  61.  
  62.  
  63. typedef pascal Boolean ( *TrackGoAwayFuncPtr ) ( WindowPtr theWindow, Point thePt );
  64. typedef UniversalProcPtr UPP;
  65.  
  66.  
  67. // ShowInit 
  68. #define kOkOldMac    128
  69. #define kOkPPC        130
  70. #define kNotOldMac    132
  71. #define kNotPPC        134
  72.  
  73. // explosion constants
  74. struct exVector {
  75.     short            theta;        // 0-360
  76.     short            speed;        // small integer
  77.     Point            pPos;        // current position
  78.     Rect            pDispR;        // current drawn size of 'bit
  79.     GWorldPtr        tPixGwP;    // map  0,0,kSrcPixSiz,kSrcPixSiz
  80. };
  81. typedef struct exVector exVector;
  82.  
  83. #define kModBits 6
  84. #define kFrameCnt 20
  85. #define kModSpeed 12
  86. #define kSrcPixSiz {0,0,3,3}
  87. #define kScratchSize 265
  88.  
  89.  
  90. //****************************************************************
  91. //                                                G L O B A L S
  92.  
  93. struct NInitGlobals
  94. {
  95.     UPP                gOrigTrackGoAway;    // old Addr
  96.     SysEnvRec        gSystemInfo;
  97.     long            gInfo;        // 1=68k,2=PPC
  98.  
  99.     Handle            gSndHandle;
  100.     SndChannelPtr    gSndChP;
  101.     exVector        *gBits;
  102.     short             gNumBits;
  103.     short             gFrameCnt;
  104.     GWorldPtr        gPad;            // working image
  105.     GWorldPtr        gSavPad;        // pristine screen copy
  106. };
  107. typedef struct NInitGlobals NInitGlobals;
  108.  
  109. NInitGlobals                *gP;
  110.  
  111.  
  112. //****************************************************************
  113. //                                                F O R W A R D S
  114.  
  115. pascal Boolean nTrackGoAway68k( WindowPtr theWindow, Point thePt);
  116. OSErr DoInitForOldMacs( void);
  117.  
  118. void PlayBoom(void);
  119. OSErr SetUpSim(void);
  120. void Animate(Point cPt);
  121. void AnimateDone(void);
  122. void ImageFrame(short frameNum, GWorldPtr dstGW, Point exPt);
  123. void PlotImage( GWorldPtr gw, short theta, short speed);
  124.  
  125. extern void ShowIconFamily(short iconId);
  126.  
  127.  
  128. //****************************************************************
  129. void main( void )
  130. {
  131.     long        oldA4, lRes;
  132.     Handle        initH = nil;        /* Handle to our own INIT resource */
  133.     OSErr        err = noErr;
  134.     
  135.     oldA4 = SetCurrentA4();            /* Get the proper value of A4 into A4 */
  136.     RememberA4();                    /* save into self-modifying code */
  137.  
  138.  
  139.     // Allocate globals struct
  140.     gP = (NInitGlobals*) NewPtrSysClear( sizeof(NInitGlobals));
  141.     if ( !gP ) {
  142.         err = memFullErr;
  143.         goto DONE;
  144.     }
  145.     
  146.      // Get minimal System Info:
  147.     err = SysEnvirons( 1, &gP->gSystemInfo );
  148.     if ( err )
  149.         goto DONE;
  150.       if ( gP->gSystemInfo.systemVersion < kMinSystemVersion ) {
  151.          err = -1;
  152.          goto DONE;
  153.      }
  154.  
  155.     // Prepare to Detach ourselves...
  156.     initH = Get1Resource( kInitRezType, kInitRezID );
  157.     if ( !initH ) {
  158.         err = resNotFound;
  159.         goto DONE;
  160.     }
  161.  
  162.     // Call Gestalt:
  163.     // Gestalt will return an err when SysArc is unimplemented
  164.     err = Gestalt( gestaltSysArchitecture, &gP->gInfo );
  165.     if ( err) gP->gInfo = gestalt68k;
  166.  
  167.     // Load 'snd ':
  168.     // this snd is marked 'sysHeap', so it'll land in the right place,
  169.     // and we have to detach anything we want to keep around
  170.     gP->gSndHandle = GetResource ('snd ', 128);
  171.     DetachResource( gP->gSndHandle);
  172.     
  173.     { // Make a new SndChannel in the System Heap
  174.     THz savZone = GetZone();
  175.     SetZone( SystemZone());
  176.     err = SndNewChannel( &gP->gSndChP, sampledSynth, initMono, 0);
  177.     if ( err != noErr) goto DONE;
  178.     SetZone( savZone);
  179.     }
  180.     
  181.     err = DoInitForOldMacs();    // sorry, 68k setup only
  182.  
  183.  
  184.     DONE:
  185.     if ( err ) {
  186.         ShowIconFamily((gP->gInfo==gestalt68k)?(kNotOldMac):(kNotPPC));
  187.         if ( gP )
  188.             DisposPtr( (Ptr)gP );
  189.     } else {
  190.         ShowIconFamily((gP->gInfo==gestalt68k)?(kOkOldMac):(kOkPPC));
  191.         DetachResource( initH);    
  192.         MoveHHi( (Handle)initH); HLock( (Handle)initH);
  193.     }
  194.     
  195.     RestoreA4( oldA4 );                    /* restore previous value of A4 */
  196. }
  197.  
  198.  
  199.  
  200. //****************************************************************
  201. //    DoInitForOldMacs
  202. //****************************************************************
  203. OSErr DoInitForOldMacs( void )
  204. {
  205.     long    oldA4;
  206.     NInitGlobals *locGPtr;
  207.  
  208.     oldA4 = SetUpA4();    
  209.     locGPtr = gP;
  210.     RestoreA4( oldA4 );    
  211.  
  212.     locGPtr->gOrigTrackGoAway = NGetTrapAddress( _TrackGoAway, ToolTrap );
  213.     NSetTrapAddress( (UPP)nTrackGoAway68k, _TrackGoAway, ToolTrap );
  214.     
  215.     return noErr;
  216. }
  217.  
  218.  
  219. //****************************************************************
  220. pascal Boolean nTrackGoAway68k( WindowPtr theWindow, Point thePt )
  221. {
  222.     Boolean        res;
  223.     long        oldA4;
  224.     GrafPtr        tPort;
  225.     Point        savPt;
  226.     TrackGoAwayFuncPtr ptr;
  227.     NInitGlobals *locGPtr;
  228.  
  229.     oldA4 = SetUpA4();        
  230.     locGPtr = gP;
  231.     
  232.     ptr = (TrackGoAwayFuncPtr)locGPtr->gOrigTrackGoAway;
  233.     savPt = thePt;
  234.     res = ( *ptr )( theWindow, thePt );
  235.     
  236.     if ( res == true) { 
  237.  
  238.         if ( locGPtr->gInfo == gestaltPowerPC || *(short*)0x17A) {
  239.             THz savZone = GetZone();
  240.             SetZone( SystemZone());
  241.             
  242.             if ( SetUpSim() == noErr) {
  243.                 HideCursor();
  244.                 Animate( savPt);
  245.                 AnimateDone();
  246.                 ShowCursor();
  247.             }
  248.             SetZone( savZone);
  249.         }    
  250.     }
  251.  
  252.     RestoreA4( oldA4 );    
  253.     return res;
  254. } 
  255.  
  256.  
  257. //***********************************************************
  258. void AnimateDone()
  259. {
  260.     short cnt;
  261.  
  262.     DisposeGWorld( gP->gPad);
  263.     DisposeGWorld( gP->gSavPad);
  264.     for ( cnt=0;cnt<gP->gNumBits; cnt++)
  265.         DisposeGWorld( gP->gBits[cnt].tPixGwP);
  266.  
  267.     DisposPtr( (Ptr)gP->gBits);
  268. }
  269.  
  270.  
  271. //***********************
  272. #define abs(x) ((x>0)?(x):(-x))
  273.  
  274. OSErr SetUpSim(void)
  275. {
  276.     short cnt, prevT;
  277.     Rect r = kSrcPixSiz;
  278.     Rect r2;
  279.     OSErr err;
  280.  
  281.     // init scratch pads
  282.     SetRect( &r2, 0, 0, kScratchSize, kScratchSize);
  283.     err = NewGWorld( &gP->gPad,8,&r2,0,0,0);    // 8 bits only, sorry
  284.     if ( err != noErr) return err;
  285.     err = NewGWorld( &gP->gSavPad,8,&r2,0,0,0);    // 8 bits only, sorry
  286.     if ( err != noErr) return err;
  287.  
  288.     // allocate 'bits array
  289.     gP->gNumBits = abs(TickCount() % kModBits) + 5;    //ok, max+n
  290.  
  291.     gP->gBits = (exVector*)NewPtrClear( gP->gNumBits*sizeof(exVector));
  292.     for ( cnt=0;cnt<gP->gNumBits; cnt++){
  293.         gP->gBits[cnt].theta = abs((TickCount()*10+cnt) % 360);
  294.         gP->gBits[cnt].speed = abs(TickCount() % kModSpeed) + 4;
  295.         gP->gBits[cnt].pPos.h = 0;
  296.         gP->gBits[cnt].pPos.v = 0;
  297.         gP->gBits[cnt].pDispR = r;
  298.  
  299.         err = NewGWorld( &gP->gBits[cnt].tPixGwP,
  300.                     8,&r,0,0,0);
  301.         if ( err != noErr) return err;
  302.  
  303.         // now, based on speed and theta, make an image
  304.         PlotImage( gP->gBits[cnt].tPixGwP, gP->gBits[cnt].theta, gP->gBits[cnt].speed);
  305.     }
  306.     return err;
  307. }
  308.  
  309.  
  310. //**************************************************************
  311. //
  312. //    Order of Events: 
  313. //    Prestine PixMap is in gP->gSavPad, working PixMap is in gP->gPad
  314. //    For each cell of animation, copy the savPad to workPad,
  315. //    Draw all 'bits for this frame, copy gP->gPad to the screen.
  316. //    
  317.                 
  318. void Animate( Point cPt)
  319. {
  320.     GrafPtr savP; GrafPort dPort;
  321.     Rect wR; long t;
  322.     short offX=0;
  323.     short offY=0;
  324.     Point    exPt;
  325.  
  326.     PlayBoom();
  327.  
  328.     GetPort( &savP);
  329.     OpenPort( &dPort);
  330.     SetPort( &dPort);
  331.  
  332.     wR = gP->gPad->portRect;    
  333.  
  334.     // if the point is closer to the side of the screen than
  335.     // half the width of our buffered draw area, then adjust
  336.     // the explosion center
  337.  
  338.     if ( cPt.h > wR.right/2) {
  339.         offX = cPt.h - wR.right/2;
  340.         exPt.h = wR.right/2;
  341.     } else exPt.h = cPt.h;
  342.     if ( cPt.v > wR.bottom/2) {
  343.         offY = cPt.v - wR.bottom/2;
  344.         exPt.v = wR.bottom/2;
  345.     } else exPt.v = cPt.v;
  346.     OffsetRect( &wR, offX, offY);
  347.  
  348.     // init savMap 
  349.     CopyBits(    (BitMap*)(&(dPort.portBits)),
  350.                 (BitMap*)(*(gP->gSavPad->portPixMap)), 
  351.                 &wR, &gP->gPad->portRect,
  352.                 patCopy, 0);
  353.                 
  354.     // special effects
  355.     {
  356.         #define kMax 6
  357.         Rect tR, exR; short cnt;
  358.         RGBColor tC = {0x0000,0x0000,0x0000};
  359.         PenMode( blend);    ForeColor( whiteColor);
  360.         exR.left = cPt.h - kScratchSize/2;
  361.         exR.right = cPt.h + kScratchSize/2;
  362.         exR.top = cPt.v - kScratchSize/2;
  363.         exR.bottom = cPt.v + kScratchSize/2;
  364.         for ( cnt=1; cnt<=kMax; cnt++){
  365.             tR = exR;
  366.             tC.red += 0x2A00; tC.green += 0x2A00; tC.blue += 0x2A00;
  367.             OpColor( &tC);
  368.             InsetRect( &tR, cnt*(kScratchSize/kMax), cnt*(kScratchSize/kMax));
  369.             PaintOval( &tR);
  370.             if ( gP->gInfo == gestaltPowerPC)
  371.                 Delay( 1, &t);
  372.         }
  373.         PenNormal();    ForeColor( blackColor);
  374.         if ( gP->gInfo == gestaltPowerPC)
  375.             Delay( 2, &t);
  376.         #undef kMax
  377.     }
  378.  
  379.     // animate
  380.     for (gP->gFrameCnt=0;gP->gFrameCnt<kFrameCnt;gP->gFrameCnt++) {
  381.         // copy savPad to workPad
  382.         CopyBits(    (BitMap*)(*(gP->gSavPad->portPixMap)), 
  383.                     (BitMap*)(*(gP->gPad->portPixMap)),
  384.                     &gP->gSavPad->portRect, &gP->gPad->portRect,
  385.                     patCopy, 0);
  386.  
  387.         ImageFrame(gP->gFrameCnt, gP->gPad, exPt);    // image 'bits
  388.  
  389.         // copy workPad to screen
  390.         CopyBits(    (BitMap*)(*(gP->gPad->portPixMap)), 
  391.                     (BitMap*)(&(dPort.portBits)),
  392.                     &gP->gPad->portRect, &wR,
  393.                     patCopy, 0);
  394.  
  395.         if ( gP->gInfo == gestaltPowerPC)
  396.             Delay( gP->gFrameCnt/4, &t);
  397.     }
  398.  
  399.     // restore screen
  400.     CopyBits(    (BitMap*)(*(gP->gSavPad->portPixMap)),
  401.                 (BitMap*)(&(dPort.portBits)), 
  402.                 &gP->gPad->portRect, &wR,
  403.                 patCopy, 0);
  404.  
  405.     SetPort( savP);
  406.     ClosePort( &dPort);
  407.     
  408.     return;
  409. }
  410.  
  411. //***********************************
  412. void ImageFrame( short frameNum, GWorldPtr dstGW, Point exPt) 
  413. {
  414.     short    posX, posY;
  415.     short    cnt, f, tSpd;
  416.     long    t;
  417.     Rect    srcR = kSrcPixSiz;
  418.     Rect    dstR;
  419.  
  420.     // r is frameCnt * speed+frameCnt
  421.     // posX = r*cos(t)
  422.     // posY = r*sin(t)
  423.     
  424.     for (f=frameNum,cnt=0;cnt<gP->gNumBits;cnt++) {
  425.         tSpd = gP->gBits[cnt].speed;
  426.         posX = (short)(f*(tSpd+cnt)) * cos(gP->gBits[cnt].theta);
  427.         posY = (short)(f*(tSpd+cnt)) * sin(gP->gBits[cnt].theta);
  428.  
  429.         dstR = gP->gBits[cnt].pDispR;
  430.  
  431.         dstR.left += exPt.h+posX;
  432.         dstR.right += exPt.h+posX;
  433.         dstR.top += exPt.v+posY;
  434.         dstR.bottom += exPt.v+posY;
  435.  
  436.         CopyBits(    (BitMap*)(*(gP->gBits[cnt].tPixGwP->portPixMap)), 
  437.                     (BitMap*)(*(dstGW->portPixMap)),
  438.                     &srcR, &dstR,
  439.                     patCopy, 0);
  440.     }
  441. }
  442.  
  443. //**********************
  444. // Create one explosion 'bit
  445. void PlotImage( GWorldPtr gw, short theta, short speed)
  446. {
  447.     GWorldPtr     savGW;
  448.     GDHandle      savGdH;
  449.     Rect        r = kSrcPixSiz;
  450.     Point        pR1a, pR1b, pR1c;
  451.     Point        pR2, pO1, pY1a, pY1b;
  452.     RGBColor    c;
  453.  
  454.     GetGWorld( &savGW, &savGdH);
  455.     SetGWorld( gw, 0);
  456.  
  457.     c.red = 0xFFFF; c.green = 0xFFFF; c.blue = 0xFFFF;
  458.     RGBForeColor( &c);
  459.     PaintRect( &r);
  460.     PenNormal();
  461.  
  462.     if ( theta <= 22) {                                                // 22
  463.         pR1a.h=1; pR1a.v=2; pR1b.h=2; pR1b.v=1; pR1c.h=1; pR1c.v=0;
  464.         pR2.h=2; pR2.v=0; pO1.h=2; pO1.v=2; 
  465.         pY1a.h=0; pY1a.v=2; pY1b.h=0; pY1b.v=0;
  466.     } else if ( theta <= 77)  {                                        // 77
  467.         pR1a.h=2; pR1a.v=2; pR1b.h=2; pR1b.v=0; pR1c.h=0; pR1c.v=0;
  468.         pR2.h=1; pR2.v=0; pO1.h=2; pO1.v=1; 
  469.         pY1a.h=1; pY1a.v=2; pY1b.h=0; pY1b.v=1;
  470.     } else if ( theta <= 112)  {                                    // 112
  471.         pR1a.h=2; pR1a.v=1; pR1b.h=1; pR1b.v=0; pR1c.h=0; pR1c.v=1;
  472.         pR2.h=0; pR2.v=0; pO1.h=2; pO1.v=0; 
  473.         pY1a.h=2; pY1a.v=2; pY1b.h=0; pY1b.v=2;
  474.     } else if ( theta <= 157)  {                                    // 157
  475.         pR1a.h=2; pR1a.v=0; pR1b.h=0; pR1b.v=0; pR1c.h=0; pR1c.v=2;
  476.         pR2.h=0; pR2.v=1; pO1.h=1; pO1.v=0; 
  477.         pY1a.h=2; pY1a.v=1; pY1b.h=1; pY1b.v=2;
  478.     } else if ( theta <= 202)  {                                    // 202
  479.         pR1a.h=1; pR1a.v=0; pR1b.h=0; pR1b.v=1; pR1c.h=1; pR1c.v=2;
  480.         pR2.h=0; pR2.v=2; pO1.h=0; pO1.v=0; 
  481.         pY1a.h=2; pY1a.v=0; pY1b.h=2; pY1b.v=2;
  482.     } else if ( theta <= 247)  {                                    // 247
  483.         pR1a.h=0; pR1a.v=0; pR1b.h=0; pR1b.v=2; pR1c.h=2; pR1c.v=2;
  484.         pR2.h=1; pR2.v=2; pO1.h=0; pO1.v=1; 
  485.         pY1a.h=1; pY1a.v=0; pY1b.h=2; pY1b.v=1;
  486.     } else if ( theta <= 292)  {                                    // 292
  487.         pR1a.h=0; pR1a.v=1; pR1b.h=1; pR1b.v=2; pR1c.h=2; pR1c.v=1;
  488.         pR2.h=2; pR2.v=2; pO1.h=0; pO1.v=2; 
  489.         pY1a.h=0; pY1a.v=0; pY1b.h=2; pY1b.v=0;
  490.     } else if ( theta <= 337)  {                                    // 337
  491.         pR1a.h=0; pR1a.v=2; pR1b.h=2; pR1b.v=2; pR1c.h=2; pR1c.v=0;
  492.         pR2.h=2; pR2.v=1; pO1.h=1; pO1.v=2; 
  493.         pY1a.h=0; pY1a.v=1; pY1b.h=1; pY1b.v=0;
  494.     } else {                                                        // +-22
  495.         pR1a.h=1; pR1a.v=2; pR1b.h=2; pR1b.v=1; pR1c.h=1; pR1c.v=0;
  496.         pR2.h=2; pR2.v=0; pO1.h=2; pO1.v=2; 
  497.         pY1a.h=0; pY1a.v=2; pY1b.h=0; pY1b.v=0;
  498.     }
  499.  
  500.     // NOTE: assumes 'bit pix size of 3x3 !!
  501.  
  502.     c.red = 0xFFFF; c.green = 0x2000; c.blue = 0;        // r1
  503.     RGBForeColor( &c);
  504.     MoveTo( pR1a.h,pR1a.v);    Line(0,0);
  505.     MoveTo( pR1b.h,pR1c.v);    Line(0,0);
  506.     MoveTo( pR1c.h,pR1c.v);    Line(0,0);
  507.  
  508.     c.red = 0xBAC7; c.green = 0; c.blue = 0;            // r2
  509.     RGBForeColor( &c);
  510.     MoveTo( pR2.h,pR2.v);    Line(0,0);
  511.     MoveTo( pO1.h,pO1.v);    Line(0,0);
  512.  
  513.     c.red = 0xFFFF; c.green = 0xCCC8; c.blue = 0;        // o2 (always center)
  514.     RGBForeColor( &c);
  515.     MoveTo( 1,1);    Line(0,0);
  516.  
  517.     c.red = 0xFFFF; c.green = 0xFFFF; c.blue = 0;        // y
  518.     RGBForeColor( &c);
  519.     MoveTo( pY1a.h,pY1a.v);    Line(0,0);
  520.     MoveTo( pY1b.h,pY1b.v);    Line(0,0);
  521.  
  522.     SetGWorld( savGW, savGdH);
  523.     return;
  524. }
  525.  
  526.  
  527. //***********************************************************
  528. void PlayBoom()
  529. {
  530.     OSErr err;
  531.  
  532.     if ( gP->gSndHandle != nil ) 
  533.         err = SndPlay( gP->gSndChP, gP->gSndHandle, true);
  534. }
  535.  
  536.  
  537. //***********************************************************************************
  538. //                                                        E N D   O F   L I S T I N G
  539.